/******************************************************************************
* 
* Freescale Semiconductor Inc.
* (c) Copyright 2013-2016 Freescale Semiconductor, Inc.
* Copyright 2016-2020 NXP
* ALL RIGHTS RESERVED.
* 
****************************************************************************//*!
* 
* @file      lin_cfg.h 
* 
* @author    FPT Software
*  
* @version   1.0 
*  
* @date      Tue Apr 28 16:08:57 CST 2020
*  
* @brief     Hardware configuration file
* 
******************************************************************************/
#ifndef    _LIN_CFG_H_  
#define    _LIN_CFG_H_  
#include "lin_hw_cfg.h" 
/* Define operating mode */
#define _MASTER_MODE_     0 
#define _SLAVE_MODE_      1 
#define LIN_MODE   _MASTER_MODE_ 
/* Define protocol version */
#define PROTOCOL_21       0  
#define PROTOCOL_J2602    1  
#define PROTOCOL_20       2 
#define LIN_PROTOCOL    PROTOCOL_21
#define LIN_NUM_OF_IFCS  1		/* For master */
/**********************************************************************/
/***************          Diagnostic class selection  *****************/
/**********************************************************************/
#define _DIAG_CLASS_I_          0
#define _DIAG_CLASS_II_         1
#define _DIAG_CLASS_III_        2

#define _DIAG_CLASS_SUPPORT_    _DIAG_CLASS_I_

#define MAX_LENGTH_SERVICE 6

#define MAX_QUEUE_SIZE 1


#define _LI0_DIAG_NUMBER_OF_SERVICES_    5

#define LI0_DIAGSRV_READ_BY_IDENTIFIER_ORDER    0

#define LI0_DIAGSRV_ASSIGN_FRAME_ID_RANGE_ORDER    1

#define LI0_DIAGSRV_ASSIGN_NAD_ORDER    2

#define LI0_DIAGSRV_CONDITIONAL_CHANGE_NAD_ORDER    3

#define LI0_DIAGSRV_SAVE_CONFIGURATION_ORDER    4


/**************** FRAME SUPPORT DEFINITION ******************/
#define _TL_SINGLE_FRAME_       0
#define _TL_MULTI_FRAME_        1

#define _TL_FRAME_SUPPORT_      _TL_SINGLE_FRAME_

/* frame buffer size */
#define LIN_FRAME_BUF_SIZE			65
#define LIN_FLAG_BUF_SIZE			20

/**********************************************************************/
/***************               Interfaces           *******************/
/**********************************************************************/
typedef enum { 
   LI0
}l_ifc_handle; 

/**********************************************************************/
/***************               Signals              *******************/
/**********************************************************************/
/* Number of signals */
#define LIN_NUM_OF_SIGS  20
/* List of signals */   
typedef enum {

   /* Interface_name = LI0 */

   LI0_ModeSelect

   , LI0_WorkMode
  
   , LI0_Indie1Error
  
   , LI0_Indie2Error
  
   , LI0_Indie3Error
  
   , LI0_Indie4Error
  
   , LI0_Indie5Error
  
   , LI0_Indie6Error
  
   , LI0_Indie7Error
  
   , LI0_Indie8Error
  
   , LI0_Indie9Error
  
   , LI0_Color1
  
   , LI0_Color2
  
   , LI0_Color3
  
   , LI0_Color4
  
   , LI0_Color5
  
   , LI0_Color6
  
   , LI0_Color7
  
   , LI0_Color8
  
   , LI0_Color9
  
  
} l_signal_handle; 
/**********************************************************************/
/*****************               Frame             ********************/
/**********************************************************************/
/* Number of frames */
#define LIN_NUM_OF_FRMS  22 
/* List of frames */
typedef enum {
/* All frames for master node */

   /* Interface_name = LI0 */

   LI0_ModeSelection

   , LI0_WorkModeSelection
  
   , LI0_Indie1Color
  
   , LI0_Indie2Color
  
   , LI0_Indie3Color
  
   , LI0_Indie4Color
  
   , LI0_Indie5Color
  
   , LI0_Indie6Color
  
   , LI0_Indie7Color
  
   , LI0_Indie8Color
  
   , LI0_Indie9Color
  
   , LI0_Indie1LINError
  
   , LI0_Indie2LINError
  
   , LI0_Indie3LINError
  
   , LI0_Indie4LINError
  
   , LI0_Indie5LINError
  
   , LI0_Indie6LINError
  
   , LI0_Indie7LINError
  
   , LI0_Indie8LINError
  
   , LI0_Indie9LINError
  
   , LI0_MasterReq
  
   , LI0_SlaveResp
  
  
} l_frame_handle; 
/**********************************************************************/
/***************        schedule table       *******************/
/**********************************************************************/
/* Number of schedule tables */
#define  LIN_NUM_OF_SCHD_TBL   6 
/* List of schedules */
typedef enum {

   /* Interface_name = LI0 */

   LI0_LIN_NULL_SCHEDULE

   ,LI0_GOTO_SLEEP_SCHEDULE
   
   ,LI0_MasterReqTable
   
   ,LI0_SlaveRespTable
   
   ,LI0_WorkTable
   
   ,LI0_InitTable
   
}l_schedule_handle;  
/**********************************************************************/
/***************             Configuration          *******************/
/**********************************************************************/

/* Size of configuration in ROM and RAM used for interface: LI0 */
#define LI0_LIN_SIZE_OF_CFG  24
 
/*********************************************************************
 * global macros
 *********************************************************************/
#define l_bool_rd(SIGNAL) l_bool_rd_##SIGNAL()
#define l_bool_wr(SIGNAL, A) l_bool_wr_##SIGNAL(A)
#define l_u8_rd(SIGNAL) l_u8_rd_##SIGNAL()
#define l_u8_wr(SIGNAL, A) l_u8_wr_##SIGNAL(A)
#define l_u16_rd(SIGNAL) l_u16_rd_##SIGNAL()
#define l_u16_wr(SIGNAL, A) l_u16_wr_##SIGNAL(A)
#define l_bytes_rd(SIGNAL, start, count, data)  l_bytes_rd_##SIGNAL(start, count, data)
#define l_bytes_wr(SIGNAL, start, count, data) l_bytes_wr_##SIGNAL(start, count, data)
#define l_flg_tst(FLAG) l_flg_tst_##FLAG()
#define l_flg_clr(FLAG) l_flg_clr_##FLAG()
#define LIN_TEST_BIT(A,B) ((l_bool)((((A) & (1U << (B))) != 0U) ? 1U : 0U))
#define LIN_SET_BIT(A,B)                      ((A) |= (l_u8) (1U << (B)))
#define LIN_CLEAR_BIT(A,B)               ((A) &= ((l_u8) (~(1U << (B)))))
#define LIN_BYTE_MASK  ((l_u16)(((l_u16)((l_u16)1 << CHAR_BIT)) - (l_u16)1))
#define LIN_FRAME_LEN_MAX                                             10U

/* Returns the low byte of the 32-bit value    */
#define BYTE_0(n)                              ((l_u8)((n) & (l_u8)0xFF))
/* Returns the second byte of the 32-bit value */
#define BYTE_1(n)                        ((l_u8)(BYTE_0((n) >> (l_u8)8)))
/* Returns the third byte of the 32-bit value  */
#define BYTE_2(n)                       ((l_u8)(BYTE_0((n) >> (l_u8)16)))
/* Returns high byte of the 32-bit value       */
#define BYTE_3(n)                       ((l_u8)(BYTE_0((n) >> (l_u8)24)))

/*
 * defines for signal access
 */


#define LIN_BYTE_OFFSET_LI0_ModeSelect    0
#define LIN_BIT_OFFSET_LI0_ModeSelect    0
#define LIN_SIGNAL_SIZE_LI0_ModeSelect    2
#define LIN_FLAG_BYTE_OFFSET_LI0_ModeSelect    0
#define LIN_FLAG_BIT_OFFSET_LI0_ModeSelect    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_ModeSelect    0

#define LIN_BYTE_OFFSET_LI0_WorkMode    1
#define LIN_BIT_OFFSET_LI0_WorkMode    0
#define LIN_SIGNAL_SIZE_LI0_WorkMode    3
#define LIN_FLAG_BYTE_OFFSET_LI0_WorkMode    1
#define LIN_FLAG_BIT_OFFSET_LI0_WorkMode    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_WorkMode    1

#define LIN_BYTE_OFFSET_LI0_Indie1Error    56
#define LIN_BIT_OFFSET_LI0_Indie1Error    0
#define LIN_SIGNAL_SIZE_LI0_Indie1Error    1
#define LIN_FLAG_BYTE_OFFSET_LI0_Indie1Error    11
#define LIN_FLAG_BIT_OFFSET_LI0_Indie1Error    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Indie1Error    11

#define LIN_BYTE_OFFSET_LI0_Indie2Error    57
#define LIN_BIT_OFFSET_LI0_Indie2Error    0
#define LIN_SIGNAL_SIZE_LI0_Indie2Error    1
#define LIN_FLAG_BYTE_OFFSET_LI0_Indie2Error    12
#define LIN_FLAG_BIT_OFFSET_LI0_Indie2Error    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Indie2Error    12

#define LIN_BYTE_OFFSET_LI0_Indie3Error    58
#define LIN_BIT_OFFSET_LI0_Indie3Error    0
#define LIN_SIGNAL_SIZE_LI0_Indie3Error    1
#define LIN_FLAG_BYTE_OFFSET_LI0_Indie3Error    13
#define LIN_FLAG_BIT_OFFSET_LI0_Indie3Error    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Indie3Error    13

#define LIN_BYTE_OFFSET_LI0_Indie4Error    59
#define LIN_BIT_OFFSET_LI0_Indie4Error    0
#define LIN_SIGNAL_SIZE_LI0_Indie4Error    1
#define LIN_FLAG_BYTE_OFFSET_LI0_Indie4Error    14
#define LIN_FLAG_BIT_OFFSET_LI0_Indie4Error    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Indie4Error    14

#define LIN_BYTE_OFFSET_LI0_Indie5Error    60
#define LIN_BIT_OFFSET_LI0_Indie5Error    0
#define LIN_SIGNAL_SIZE_LI0_Indie5Error    1
#define LIN_FLAG_BYTE_OFFSET_LI0_Indie5Error    15
#define LIN_FLAG_BIT_OFFSET_LI0_Indie5Error    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Indie5Error    15

#define LIN_BYTE_OFFSET_LI0_Indie6Error    61
#define LIN_BIT_OFFSET_LI0_Indie6Error    0
#define LIN_SIGNAL_SIZE_LI0_Indie6Error    1
#define LIN_FLAG_BYTE_OFFSET_LI0_Indie6Error    16
#define LIN_FLAG_BIT_OFFSET_LI0_Indie6Error    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Indie6Error    16

#define LIN_BYTE_OFFSET_LI0_Indie7Error    62
#define LIN_BIT_OFFSET_LI0_Indie7Error    0
#define LIN_SIGNAL_SIZE_LI0_Indie7Error    1
#define LIN_FLAG_BYTE_OFFSET_LI0_Indie7Error    17
#define LIN_FLAG_BIT_OFFSET_LI0_Indie7Error    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Indie7Error    17

#define LIN_BYTE_OFFSET_LI0_Indie8Error    63
#define LIN_BIT_OFFSET_LI0_Indie8Error    0
#define LIN_SIGNAL_SIZE_LI0_Indie8Error    1
#define LIN_FLAG_BYTE_OFFSET_LI0_Indie8Error    18
#define LIN_FLAG_BIT_OFFSET_LI0_Indie8Error    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Indie8Error    18

#define LIN_BYTE_OFFSET_LI0_Indie9Error    64
#define LIN_BIT_OFFSET_LI0_Indie9Error    0
#define LIN_SIGNAL_SIZE_LI0_Indie9Error    1
#define LIN_FLAG_BYTE_OFFSET_LI0_Indie9Error    19
#define LIN_FLAG_BIT_OFFSET_LI0_Indie9Error    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Indie9Error    19

#define LIN_BYTE_OFFSET_LI0_Color1    2
#define LIN_BIT_OFFSET_LI0_Color1    0
#define LIN_SIGNAL_SIZE_LI0_Color1    48
#define LIN_FLAG_BYTE_OFFSET_LI0_Color1    2
#define LIN_FLAG_BIT_OFFSET_LI0_Color1    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Color1    2

#define LIN_BYTE_OFFSET_LI0_Color2    8
#define LIN_BIT_OFFSET_LI0_Color2    0
#define LIN_SIGNAL_SIZE_LI0_Color2    48
#define LIN_FLAG_BYTE_OFFSET_LI0_Color2    3
#define LIN_FLAG_BIT_OFFSET_LI0_Color2    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Color2    3

#define LIN_BYTE_OFFSET_LI0_Color3    14
#define LIN_BIT_OFFSET_LI0_Color3    0
#define LIN_SIGNAL_SIZE_LI0_Color3    48
#define LIN_FLAG_BYTE_OFFSET_LI0_Color3    4
#define LIN_FLAG_BIT_OFFSET_LI0_Color3    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Color3    4

#define LIN_BYTE_OFFSET_LI0_Color4    20
#define LIN_BIT_OFFSET_LI0_Color4    0
#define LIN_SIGNAL_SIZE_LI0_Color4    48
#define LIN_FLAG_BYTE_OFFSET_LI0_Color4    5
#define LIN_FLAG_BIT_OFFSET_LI0_Color4    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Color4    5

#define LIN_BYTE_OFFSET_LI0_Color5    26
#define LIN_BIT_OFFSET_LI0_Color5    0
#define LIN_SIGNAL_SIZE_LI0_Color5    48
#define LIN_FLAG_BYTE_OFFSET_LI0_Color5    6
#define LIN_FLAG_BIT_OFFSET_LI0_Color5    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Color5    6

#define LIN_BYTE_OFFSET_LI0_Color6    32
#define LIN_BIT_OFFSET_LI0_Color6    0
#define LIN_SIGNAL_SIZE_LI0_Color6    48
#define LIN_FLAG_BYTE_OFFSET_LI0_Color6    7
#define LIN_FLAG_BIT_OFFSET_LI0_Color6    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Color6    7

#define LIN_BYTE_OFFSET_LI0_Color7    38
#define LIN_BIT_OFFSET_LI0_Color7    0
#define LIN_SIGNAL_SIZE_LI0_Color7    48
#define LIN_FLAG_BYTE_OFFSET_LI0_Color7    8
#define LIN_FLAG_BIT_OFFSET_LI0_Color7    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Color7    8

#define LIN_BYTE_OFFSET_LI0_Color8    44
#define LIN_BIT_OFFSET_LI0_Color8    0
#define LIN_SIGNAL_SIZE_LI0_Color8    48
#define LIN_FLAG_BYTE_OFFSET_LI0_Color8    9
#define LIN_FLAG_BIT_OFFSET_LI0_Color8    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Color8    9

#define LIN_BYTE_OFFSET_LI0_Color9    50
#define LIN_BIT_OFFSET_LI0_Color9    0
#define LIN_SIGNAL_SIZE_LI0_Color9    48
#define LIN_FLAG_BYTE_OFFSET_LI0_Color9    10
#define LIN_FLAG_BIT_OFFSET_LI0_Color9    0
#define LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Color9    10




#define LIN_FLAG_BYTE_OFFSET_LI0_ModeSelection             0
#define LIN_FLAG_BIT_OFFSET_LI0_ModeSelection              0

#define LIN_FLAG_BYTE_OFFSET_LI0_WorkModeSelection             1
#define LIN_FLAG_BIT_OFFSET_LI0_WorkModeSelection              0

#define LIN_FLAG_BYTE_OFFSET_LI0_Indie1Color             2
#define LIN_FLAG_BIT_OFFSET_LI0_Indie1Color              0

#define LIN_FLAG_BYTE_OFFSET_LI0_Indie2Color             3
#define LIN_FLAG_BIT_OFFSET_LI0_Indie2Color              0

#define LIN_FLAG_BYTE_OFFSET_LI0_Indie3Color             4
#define LIN_FLAG_BIT_OFFSET_LI0_Indie3Color              0

#define LIN_FLAG_BYTE_OFFSET_LI0_Indie4Color             5
#define LIN_FLAG_BIT_OFFSET_LI0_Indie4Color              0

#define LIN_FLAG_BYTE_OFFSET_LI0_Indie5Color             6
#define LIN_FLAG_BIT_OFFSET_LI0_Indie5Color              0

#define LIN_FLAG_BYTE_OFFSET_LI0_Indie6Color             7
#define LIN_FLAG_BIT_OFFSET_LI0_Indie6Color              0

#define LIN_FLAG_BYTE_OFFSET_LI0_Indie7Color             8
#define LIN_FLAG_BIT_OFFSET_LI0_Indie7Color              0

#define LIN_FLAG_BYTE_OFFSET_LI0_Indie8Color             9
#define LIN_FLAG_BIT_OFFSET_LI0_Indie8Color              0

#define LIN_FLAG_BYTE_OFFSET_LI0_Indie9Color             10
#define LIN_FLAG_BIT_OFFSET_LI0_Indie9Color              0

#define LIN_FLAG_BYTE_OFFSET_LI0_Indie1LINError             11
#define LIN_FLAG_BIT_OFFSET_LI0_Indie1LINError              0

#define LIN_FLAG_BYTE_OFFSET_LI0_Indie2LINError             12
#define LIN_FLAG_BIT_OFFSET_LI0_Indie2LINError              0

#define LIN_FLAG_BYTE_OFFSET_LI0_Indie3LINError             13
#define LIN_FLAG_BIT_OFFSET_LI0_Indie3LINError              0

#define LIN_FLAG_BYTE_OFFSET_LI0_Indie4LINError             14
#define LIN_FLAG_BIT_OFFSET_LI0_Indie4LINError              0

#define LIN_FLAG_BYTE_OFFSET_LI0_Indie5LINError             15
#define LIN_FLAG_BIT_OFFSET_LI0_Indie5LINError              0

#define LIN_FLAG_BYTE_OFFSET_LI0_Indie6LINError             16
#define LIN_FLAG_BIT_OFFSET_LI0_Indie6LINError              0

#define LIN_FLAG_BYTE_OFFSET_LI0_Indie7LINError             17
#define LIN_FLAG_BIT_OFFSET_LI0_Indie7LINError              0

#define LIN_FLAG_BYTE_OFFSET_LI0_Indie8LINError             18
#define LIN_FLAG_BIT_OFFSET_LI0_Indie8LINError              0

#define LIN_FLAG_BYTE_OFFSET_LI0_Indie9LINError             19
#define LIN_FLAG_BIT_OFFSET_LI0_Indie9LINError              0


/**********************************************************************/
/***************        Static API Functions        *******************/
/**********************************************************************/
/*
 * the static signal access macros
 */


/* static access macros for signal LI0_ModeSelect */
   
#define l_u8_rd_LI0_ModeSelect() \
    ((l_u8) ((lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_ModeSelect] & \
    (((1U << LIN_SIGNAL_SIZE_LI0_ModeSelect) - 1) \
    << LIN_BIT_OFFSET_LI0_ModeSelect )) >> LIN_BIT_OFFSET_LI0_ModeSelect))
#define l_u8_wr_LI0_ModeSelect(A) \
    {lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_ModeSelect] = \
    ((l_u8) (((l_u8) (lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_ModeSelect] & \
    ((l_u8) (~(((1U << LIN_SIGNAL_SIZE_LI0_ModeSelect) - 1) << LIN_BIT_OFFSET_LI0_ModeSelect)))))  | \
    ((l_u8) ((((1U << LIN_SIGNAL_SIZE_LI0_ModeSelect) - 1) & (A)) << LIN_BIT_OFFSET_LI0_ModeSelect))));\
    lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_ModeSelect] = 1;}

/* static access macros for signal LI0_WorkMode */
   
#define l_u8_rd_LI0_WorkMode() \
    ((l_u8) ((lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_WorkMode] & \
    (((1U << LIN_SIGNAL_SIZE_LI0_WorkMode) - 1) \
    << LIN_BIT_OFFSET_LI0_WorkMode )) >> LIN_BIT_OFFSET_LI0_WorkMode))
#define l_u8_wr_LI0_WorkMode(A) \
    {lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_WorkMode] = \
    ((l_u8) (((l_u8) (lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_WorkMode] & \
    ((l_u8) (~(((1U << LIN_SIGNAL_SIZE_LI0_WorkMode) - 1) << LIN_BIT_OFFSET_LI0_WorkMode)))))  | \
    ((l_u8) ((((1U << LIN_SIGNAL_SIZE_LI0_WorkMode) - 1) & (A)) << LIN_BIT_OFFSET_LI0_WorkMode))));\
    lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_WorkMode] = 1;}

/* static access macros for signal LI0_Indie1Error */
   
#define l_bool_rd_LI0_Indie1Error() \
   	(LIN_TEST_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie1Error], \
   	LIN_BIT_OFFSET_LI0_Indie1Error))
#define l_bool_wr_LI0_Indie1Error(A) \
	{(A) ? \
  	(LIN_SET_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie1Error], \
  	LIN_BIT_OFFSET_LI0_Indie1Error)):\
  	(LIN_CLEAR_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie1Error], \
  	LIN_BIT_OFFSET_LI0_Indie1Error));\
  	lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Indie1Error] = 1;}

/* static access macros for signal LI0_Indie2Error */
   
#define l_bool_rd_LI0_Indie2Error() \
   	(LIN_TEST_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie2Error], \
   	LIN_BIT_OFFSET_LI0_Indie2Error))
#define l_bool_wr_LI0_Indie2Error(A) \
	{(A) ? \
  	(LIN_SET_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie2Error], \
  	LIN_BIT_OFFSET_LI0_Indie2Error)):\
  	(LIN_CLEAR_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie2Error], \
  	LIN_BIT_OFFSET_LI0_Indie2Error));\
  	lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Indie2Error] = 1;}

/* static access macros for signal LI0_Indie3Error */
   
#define l_bool_rd_LI0_Indie3Error() \
   	(LIN_TEST_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie3Error], \
   	LIN_BIT_OFFSET_LI0_Indie3Error))
#define l_bool_wr_LI0_Indie3Error(A) \
	{(A) ? \
  	(LIN_SET_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie3Error], \
  	LIN_BIT_OFFSET_LI0_Indie3Error)):\
  	(LIN_CLEAR_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie3Error], \
  	LIN_BIT_OFFSET_LI0_Indie3Error));\
  	lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Indie3Error] = 1;}

/* static access macros for signal LI0_Indie4Error */
   
#define l_bool_rd_LI0_Indie4Error() \
   	(LIN_TEST_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie4Error], \
   	LIN_BIT_OFFSET_LI0_Indie4Error))
#define l_bool_wr_LI0_Indie4Error(A) \
	{(A) ? \
  	(LIN_SET_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie4Error], \
  	LIN_BIT_OFFSET_LI0_Indie4Error)):\
  	(LIN_CLEAR_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie4Error], \
  	LIN_BIT_OFFSET_LI0_Indie4Error));\
  	lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Indie4Error] = 1;}

/* static access macros for signal LI0_Indie5Error */
   
#define l_bool_rd_LI0_Indie5Error() \
   	(LIN_TEST_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie5Error], \
   	LIN_BIT_OFFSET_LI0_Indie5Error))
#define l_bool_wr_LI0_Indie5Error(A) \
	{(A) ? \
  	(LIN_SET_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie5Error], \
  	LIN_BIT_OFFSET_LI0_Indie5Error)):\
  	(LIN_CLEAR_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie5Error], \
  	LIN_BIT_OFFSET_LI0_Indie5Error));\
  	lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Indie5Error] = 1;}

/* static access macros for signal LI0_Indie6Error */
   
#define l_bool_rd_LI0_Indie6Error() \
   	(LIN_TEST_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie6Error], \
   	LIN_BIT_OFFSET_LI0_Indie6Error))
#define l_bool_wr_LI0_Indie6Error(A) \
	{(A) ? \
  	(LIN_SET_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie6Error], \
  	LIN_BIT_OFFSET_LI0_Indie6Error)):\
  	(LIN_CLEAR_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie6Error], \
  	LIN_BIT_OFFSET_LI0_Indie6Error));\
  	lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Indie6Error] = 1;}

/* static access macros for signal LI0_Indie7Error */
   
#define l_bool_rd_LI0_Indie7Error() \
   	(LIN_TEST_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie7Error], \
   	LIN_BIT_OFFSET_LI0_Indie7Error))
#define l_bool_wr_LI0_Indie7Error(A) \
	{(A) ? \
  	(LIN_SET_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie7Error], \
  	LIN_BIT_OFFSET_LI0_Indie7Error)):\
  	(LIN_CLEAR_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie7Error], \
  	LIN_BIT_OFFSET_LI0_Indie7Error));\
  	lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Indie7Error] = 1;}

/* static access macros for signal LI0_Indie8Error */
   
#define l_bool_rd_LI0_Indie8Error() \
   	(LIN_TEST_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie8Error], \
   	LIN_BIT_OFFSET_LI0_Indie8Error))
#define l_bool_wr_LI0_Indie8Error(A) \
	{(A) ? \
  	(LIN_SET_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie8Error], \
  	LIN_BIT_OFFSET_LI0_Indie8Error)):\
  	(LIN_CLEAR_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie8Error], \
  	LIN_BIT_OFFSET_LI0_Indie8Error));\
  	lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Indie8Error] = 1;}

/* static access macros for signal LI0_Indie9Error */
   
#define l_bool_rd_LI0_Indie9Error() \
   	(LIN_TEST_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie9Error], \
   	LIN_BIT_OFFSET_LI0_Indie9Error))
#define l_bool_wr_LI0_Indie9Error(A) \
	{(A) ? \
  	(LIN_SET_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie9Error], \
  	LIN_BIT_OFFSET_LI0_Indie9Error)):\
  	(LIN_CLEAR_BIT(lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Indie9Error], \
  	LIN_BIT_OFFSET_LI0_Indie9Error));\
  	lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Indie9Error] = 1;}

/* static access macros for signal LI0_Color1 */
  
#define l_bytes_rd_LI0_Color1(start, count, data) \
  	{l_u8       i; \
     for (i = 0; i < (count); ++i)  (data)[i] = lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Color1 + i + (start)];}
#define l_bytes_wr_LI0_Color1(start, count, data) \
  	{l_u8       i; \
     for (i = 0; i < (count); ++i)lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Color1 + i + (start)]  = (data)[i]; \
  	 lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Color1] = 1;}

/* static access macros for signal LI0_Color2 */
  
#define l_bytes_rd_LI0_Color2(start, count, data) \
  	{l_u8       i; \
     for (i = 0; i < (count); ++i)  (data)[i] = lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Color2 + i + (start)];}
#define l_bytes_wr_LI0_Color2(start, count, data) \
  	{l_u8       i; \
     for (i = 0; i < (count); ++i)lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Color2 + i + (start)]  = (data)[i]; \
  	 lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Color2] = 1;}

/* static access macros for signal LI0_Color3 */
  
#define l_bytes_rd_LI0_Color3(start, count, data) \
  	{l_u8       i; \
     for (i = 0; i < (count); ++i)  (data)[i] = lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Color3 + i + (start)];}
#define l_bytes_wr_LI0_Color3(start, count, data) \
  	{l_u8       i; \
     for (i = 0; i < (count); ++i)lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Color3 + i + (start)]  = (data)[i]; \
  	 lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Color3] = 1;}

/* static access macros for signal LI0_Color4 */
  
#define l_bytes_rd_LI0_Color4(start, count, data) \
  	{l_u8       i; \
     for (i = 0; i < (count); ++i)  (data)[i] = lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Color4 + i + (start)];}
#define l_bytes_wr_LI0_Color4(start, count, data) \
  	{l_u8       i; \
     for (i = 0; i < (count); ++i)lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Color4 + i + (start)]  = (data)[i]; \
  	 lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Color4] = 1;}

/* static access macros for signal LI0_Color5 */
  
#define l_bytes_rd_LI0_Color5(start, count, data) \
  	{l_u8       i; \
     for (i = 0; i < (count); ++i)  (data)[i] = lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Color5 + i + (start)];}
#define l_bytes_wr_LI0_Color5(start, count, data) \
  	{l_u8       i; \
     for (i = 0; i < (count); ++i)lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Color5 + i + (start)]  = (data)[i]; \
  	 lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Color5] = 1;}

/* static access macros for signal LI0_Color6 */
  
#define l_bytes_rd_LI0_Color6(start, count, data) \
  	{l_u8       i; \
     for (i = 0; i < (count); ++i)  (data)[i] = lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Color6 + i + (start)];}
#define l_bytes_wr_LI0_Color6(start, count, data) \
  	{l_u8       i; \
     for (i = 0; i < (count); ++i)lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Color6 + i + (start)]  = (data)[i]; \
  	 lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Color6] = 1;}

/* static access macros for signal LI0_Color7 */
  
#define l_bytes_rd_LI0_Color7(start, count, data) \
  	{l_u8       i; \
     for (i = 0; i < (count); ++i)  (data)[i] = lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Color7 + i + (start)];}
#define l_bytes_wr_LI0_Color7(start, count, data) \
  	{l_u8       i; \
     for (i = 0; i < (count); ++i)lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Color7 + i + (start)]  = (data)[i]; \
  	 lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Color7] = 1;}

/* static access macros for signal LI0_Color8 */
  
#define l_bytes_rd_LI0_Color8(start, count, data) \
  	{l_u8       i; \
     for (i = 0; i < (count); ++i)  (data)[i] = lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Color8 + i + (start)];}
#define l_bytes_wr_LI0_Color8(start, count, data) \
  	{l_u8       i; \
     for (i = 0; i < (count); ++i)lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Color8 + i + (start)]  = (data)[i]; \
  	 lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Color8] = 1;}

/* static access macros for signal LI0_Color9 */
  
#define l_bytes_rd_LI0_Color9(start, count, data) \
  	{l_u8       i; \
     for (i = 0; i < (count); ++i)  (data)[i] = lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Color9 + i + (start)];}
#define l_bytes_wr_LI0_Color9(start, count, data) \
  	{l_u8       i; \
     for (i = 0; i < (count); ++i)lin_pFrameBuf[LIN_BYTE_OFFSET_LI0_Color9 + i + (start)]  = (data)[i]; \
  	 lin_frame_flag_tbl[LIN_FLAG_UPDATE_BYTE_OFFSET_LI0_Color9] = 1;}







/* Signal flag APIs */

#define l_flg_tst_LI0_ModeSelect_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_ModeSelect],\
         LIN_FLAG_BIT_OFFSET_LI0_ModeSelect)
#define l_flg_clr_LI0_ModeSelect_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_ModeSelect],\
         LIN_FLAG_BIT_OFFSET_LI0_ModeSelect)

#define l_flg_tst_LI0_WorkMode_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_WorkMode],\
         LIN_FLAG_BIT_OFFSET_LI0_WorkMode)
#define l_flg_clr_LI0_WorkMode_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_WorkMode],\
         LIN_FLAG_BIT_OFFSET_LI0_WorkMode)

#define l_flg_tst_LI0_Indie1Error_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie1Error],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie1Error)
#define l_flg_clr_LI0_Indie1Error_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie1Error],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie1Error)

#define l_flg_tst_LI0_Indie2Error_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie2Error],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie2Error)
#define l_flg_clr_LI0_Indie2Error_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie2Error],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie2Error)

#define l_flg_tst_LI0_Indie3Error_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie3Error],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie3Error)
#define l_flg_clr_LI0_Indie3Error_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie3Error],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie3Error)

#define l_flg_tst_LI0_Indie4Error_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie4Error],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie4Error)
#define l_flg_clr_LI0_Indie4Error_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie4Error],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie4Error)

#define l_flg_tst_LI0_Indie5Error_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie5Error],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie5Error)
#define l_flg_clr_LI0_Indie5Error_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie5Error],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie5Error)

#define l_flg_tst_LI0_Indie6Error_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie6Error],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie6Error)
#define l_flg_clr_LI0_Indie6Error_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie6Error],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie6Error)

#define l_flg_tst_LI0_Indie7Error_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie7Error],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie7Error)
#define l_flg_clr_LI0_Indie7Error_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie7Error],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie7Error)

#define l_flg_tst_LI0_Indie8Error_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie8Error],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie8Error)
#define l_flg_clr_LI0_Indie8Error_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie8Error],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie8Error)

#define l_flg_tst_LI0_Indie9Error_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie9Error],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie9Error)
#define l_flg_clr_LI0_Indie9Error_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie9Error],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie9Error)

#define l_flg_tst_LI0_Color1_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Color1],\
         LIN_FLAG_BIT_OFFSET_LI0_Color1)
#define l_flg_clr_LI0_Color1_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Color1],\
         LIN_FLAG_BIT_OFFSET_LI0_Color1)

#define l_flg_tst_LI0_Color2_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Color2],\
         LIN_FLAG_BIT_OFFSET_LI0_Color2)
#define l_flg_clr_LI0_Color2_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Color2],\
         LIN_FLAG_BIT_OFFSET_LI0_Color2)

#define l_flg_tst_LI0_Color3_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Color3],\
         LIN_FLAG_BIT_OFFSET_LI0_Color3)
#define l_flg_clr_LI0_Color3_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Color3],\
         LIN_FLAG_BIT_OFFSET_LI0_Color3)

#define l_flg_tst_LI0_Color4_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Color4],\
         LIN_FLAG_BIT_OFFSET_LI0_Color4)
#define l_flg_clr_LI0_Color4_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Color4],\
         LIN_FLAG_BIT_OFFSET_LI0_Color4)

#define l_flg_tst_LI0_Color5_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Color5],\
         LIN_FLAG_BIT_OFFSET_LI0_Color5)
#define l_flg_clr_LI0_Color5_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Color5],\
         LIN_FLAG_BIT_OFFSET_LI0_Color5)

#define l_flg_tst_LI0_Color6_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Color6],\
         LIN_FLAG_BIT_OFFSET_LI0_Color6)
#define l_flg_clr_LI0_Color6_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Color6],\
         LIN_FLAG_BIT_OFFSET_LI0_Color6)

#define l_flg_tst_LI0_Color7_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Color7],\
         LIN_FLAG_BIT_OFFSET_LI0_Color7)
#define l_flg_clr_LI0_Color7_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Color7],\
         LIN_FLAG_BIT_OFFSET_LI0_Color7)

#define l_flg_tst_LI0_Color8_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Color8],\
         LIN_FLAG_BIT_OFFSET_LI0_Color8)
#define l_flg_clr_LI0_Color8_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Color8],\
         LIN_FLAG_BIT_OFFSET_LI0_Color8)

#define l_flg_tst_LI0_Color9_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Color9],\
         LIN_FLAG_BIT_OFFSET_LI0_Color9)
#define l_flg_clr_LI0_Color9_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Color9],\
         LIN_FLAG_BIT_OFFSET_LI0_Color9)



/* Frame flag APIs */

#define l_flg_tst_LI0_ModeSelection_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_ModeSelection],\
         LIN_FLAG_BIT_OFFSET_LI0_ModeSelection)
#define l_flg_clr_LI0_ModeSelection_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_ModeSelection],\
         LIN_FLAG_BIT_OFFSET_LI0_ModeSelection)

#define l_flg_tst_LI0_WorkModeSelection_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_WorkModeSelection],\
         LIN_FLAG_BIT_OFFSET_LI0_WorkModeSelection)
#define l_flg_clr_LI0_WorkModeSelection_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_WorkModeSelection],\
         LIN_FLAG_BIT_OFFSET_LI0_WorkModeSelection)

#define l_flg_tst_LI0_Indie1Color_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie1Color],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie1Color)
#define l_flg_clr_LI0_Indie1Color_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie1Color],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie1Color)

#define l_flg_tst_LI0_Indie2Color_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie2Color],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie2Color)
#define l_flg_clr_LI0_Indie2Color_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie2Color],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie2Color)

#define l_flg_tst_LI0_Indie3Color_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie3Color],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie3Color)
#define l_flg_clr_LI0_Indie3Color_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie3Color],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie3Color)

#define l_flg_tst_LI0_Indie4Color_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie4Color],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie4Color)
#define l_flg_clr_LI0_Indie4Color_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie4Color],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie4Color)

#define l_flg_tst_LI0_Indie5Color_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie5Color],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie5Color)
#define l_flg_clr_LI0_Indie5Color_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie5Color],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie5Color)

#define l_flg_tst_LI0_Indie6Color_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie6Color],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie6Color)
#define l_flg_clr_LI0_Indie6Color_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie6Color],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie6Color)

#define l_flg_tst_LI0_Indie7Color_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie7Color],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie7Color)
#define l_flg_clr_LI0_Indie7Color_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie7Color],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie7Color)

#define l_flg_tst_LI0_Indie8Color_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie8Color],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie8Color)
#define l_flg_clr_LI0_Indie8Color_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie8Color],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie8Color)

#define l_flg_tst_LI0_Indie9Color_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie9Color],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie9Color)
#define l_flg_clr_LI0_Indie9Color_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie9Color],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie9Color)

#define l_flg_tst_LI0_Indie1LINError_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie1LINError],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie1LINError)
#define l_flg_clr_LI0_Indie1LINError_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie1LINError],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie1LINError)

#define l_flg_tst_LI0_Indie2LINError_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie2LINError],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie2LINError)
#define l_flg_clr_LI0_Indie2LINError_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie2LINError],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie2LINError)

#define l_flg_tst_LI0_Indie3LINError_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie3LINError],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie3LINError)
#define l_flg_clr_LI0_Indie3LINError_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie3LINError],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie3LINError)

#define l_flg_tst_LI0_Indie4LINError_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie4LINError],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie4LINError)
#define l_flg_clr_LI0_Indie4LINError_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie4LINError],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie4LINError)

#define l_flg_tst_LI0_Indie5LINError_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie5LINError],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie5LINError)
#define l_flg_clr_LI0_Indie5LINError_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie5LINError],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie5LINError)

#define l_flg_tst_LI0_Indie6LINError_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie6LINError],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie6LINError)
#define l_flg_clr_LI0_Indie6LINError_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie6LINError],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie6LINError)

#define l_flg_tst_LI0_Indie7LINError_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie7LINError],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie7LINError)
#define l_flg_clr_LI0_Indie7LINError_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie7LINError],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie7LINError)

#define l_flg_tst_LI0_Indie8LINError_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie8LINError],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie8LINError)
#define l_flg_clr_LI0_Indie8LINError_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie8LINError],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie8LINError)

#define l_flg_tst_LI0_Indie9LINError_flag() \
         LIN_TEST_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie9LINError],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie9LINError)
#define l_flg_clr_LI0_Indie9LINError_flag() \
         LIN_CLEAR_BIT(lin_flag_handle_tbl[LIN_FLAG_BYTE_OFFSET_LI0_Indie9LINError],\
         LIN_FLAG_BIT_OFFSET_LI0_Indie9LINError)



/* SCHEDULE MANAGEMENT */

#define l_sch_tick_LI0() l_sch_tick(LI0)



#define l_sch_set_LI0(schedule, entry) l_sch_set(LI0, schedule, entry)

/* INTERFACE MANAGEMENT */

#define l_ifc_init_LI0() l_ifc_init(LI0)



#define l_ifc_goto_sleep_LI0() l_ifc_goto_sleep(LI0)


#define l_ifc_wake_up_LI0() l_ifc_wake_up(LI0)



#define l_ifc_rx_LI0() l_ifc_rx(LI0)



#define l_ifc_tx_LI0() l_ifc_tx(LI0)



#define l_ifc_aux_LI0() l_ifc_aux(LI0)



#define l_ifc_read_status_LI0() l_ifc_read_status(LI0)


#endif    /* _LIN_CFG_H_ */